/*
 * Copyright 2006 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "include/effects/SkDashPathEffect.h"

#include "include/core/SkFlattenable.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkStrokeRec.h"
#include "include/private/base/SkAlign.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkWriteBuffer.h"
#include "include/effects/SkDashImpl.h"
// #include "src/utils/SkDashPathPriv.h"

#include <algorithm>
#include <cstdint>
#include <cstring>

using namespace skia_private;

SkDashImpl::SkDashImpl(const SkScalar intervals[], int count, SkScalar phase)
        : fPhase(0)
        , fInitialDashLength(-1)
        , fInitialDashIndex(0)
        , fIntervalLength(0) {
    SkASSERT(intervals);
    SkASSERT(count > 1 && SkIsAlign2(count));

    fIntervals = (SkScalar*)sk_malloc_throw(sizeof(SkScalar) * count);
    fCount = count;
    for (int i = 0; i < count; i++) {
        fIntervals[i] = intervals[i];
    }
    //     // set the internal data members
    //     SkDashPath::CalcDashParameters(phase, fIntervals, fCount,
    //             &fInitialDashLength, &fInitialDashIndex, &fIntervalLength, &

    std::vector<float> tmpFloats(count);
    for (size_t i = 0; i < count; i++) {
        tmpFloats[i] = intervals[i];
    }

    fOHPathEffect = OH_Drawing_CreateDashPathEffect(tmpFloats.data(), count, phase);
    
    DrawingHash hasher;
    hasher.push(HASH_UNIQUE_ID);
    hasher.pushArray(intervals, count);
    hasher.push(phase);
    fHash = hasher.digest();
}

SkDashImpl::~SkDashImpl() {
    sk_free(fIntervals);
}

bool SkDashImpl::onFilterPath(SkPath* dst, const SkPath& src, SkStrokeRec* rec,
                              const SkRect* cullRect, const SkMatrix&) const {
    RENDER_UNIMPLEMENTED;
    return false;
//     return SkDashPath::InternalFilter(dst, src, rec, cullRect, fIntervals, fCount,
//                                       fInitialDashLength, fInitialDashIndex, fIntervalLength,
//                                       fPhase);
}

static void outset_for_stroke(SkRect* rect, const SkStrokeRec& rec) {
    SkScalar radius = SkScalarHalf(rec.getWidth());
    if (0 == radius) {
        radius = SK_Scalar1;    // hairlines
    }
    if (SkPaint::kMiter_Join == rec.getJoin()) {
        radius *= rec.getMiter();
    }
    rect->outset(radius, radius);
}

// Attempt to trim the line to minimally cover the cull rect (currently
// only works for horizontal and vertical lines).
// Return true if processing should continue; false otherwise.
static bool cull_line(SkPoint* pts, const SkStrokeRec& rec,
                      const SkMatrix& ctm, const SkRect* cullRect,
                      const SkScalar intervalLength) {
    if (nullptr == cullRect) {
        SkASSERT(false); // Shouldn't ever occur in practice
        return false;
    }

    SkScalar dx = pts[1].x() - pts[0].x();
    SkScalar dy = pts[1].y() - pts[0].y();

    if ((dx && dy) || (!dx && !dy)) {
        return false;
    }

    SkRect bounds = *cullRect;
    outset_for_stroke(&bounds, rec);

    // cullRect is in device space while pts are in the local coordinate system
    // defined by the ctm. We want our answer in the local coordinate system.

    SkASSERT(ctm.rectStaysRect());
    SkMatrix inv;
    if (!ctm.invert(&inv)) {
        return false;
    }

    inv.mapRect(&bounds);

    if (dx) {
        SkASSERT(dx && !dy);
        SkScalar minX = pts[0].fX;
        SkScalar maxX = pts[1].fX;

        if (dx < 0) {
            using std::swap;
            swap(minX, maxX);
        }

        SkASSERT(minX < maxX);
        if (maxX <= bounds.fLeft || minX >= bounds.fRight) {
            return false;
        }

        // Now we actually perform the chop, removing the excess to the left and
        // right of the bounds (keeping our new line "in phase" with the dash,
        // hence the (mod intervalLength).

        if (minX < bounds.fLeft) {
            minX = bounds.fLeft - SkScalarMod(bounds.fLeft - minX, intervalLength);
        }
        if (maxX > bounds.fRight) {
            maxX = bounds.fRight + SkScalarMod(maxX - bounds.fRight, intervalLength);
        }

        SkASSERT(maxX > minX);
        if (dx < 0) {
            using std::swap;
            swap(minX, maxX);
        }
        pts[0].fX = minX;
        pts[1].fX = maxX;
    } else {
        SkASSERT(dy && !dx);
        SkScalar minY = pts[0].fY;
        SkScalar maxY = pts[1].fY;

        if (dy < 0) {
            using std::swap;
            swap(minY, maxY);
        }

        SkASSERT(minY < maxY);
        if (maxY <= bounds.fTop || minY >= bounds.fBottom) {
            return false;
        }

        // Now we actually perform the chop, removing the excess to the top and
        // bottom of the bounds (keeping our new line "in phase" with the dash,
        // hence the (mod intervalLength).

        if (minY < bounds.fTop) {
            minY = bounds.fTop - SkScalarMod(bounds.fTop - minY, intervalLength);
        }
        if (maxY > bounds.fBottom) {
            maxY = bounds.fBottom + SkScalarMod(maxY - bounds.fBottom, intervalLength);
        }

        SkASSERT(maxY > minY);
        if (dy < 0) {
            using std::swap;
            swap(minY, maxY);
        }
        pts[0].fY = minY;
        pts[1].fY = maxY;
    }

    return true;
}

// Currently asPoints is more restrictive then it needs to be. In the future
// we need to:
//      allow kRound_Cap capping (could allow rotations in the matrix with this)
//      allow paths to be returned
bool SkDashImpl::onAsPoints(PointData* results, const SkPath& src, const SkStrokeRec& rec,
                            const SkMatrix& matrix, const SkRect* cullRect) const {
    RENDER_UNIMPLEMENTED;
    return false;
//     // width < 0 -> fill && width == 0 -> hairline so requiring width > 0 rules both out
//     if (0 >= rec.getWidth()) {
//         return false;
//     }
//
//     // TODO: this next test could be eased up. We could allow any number of
//     // intervals as long as all the ons match and all the offs match.
//     // Additionally, they do not necessarily need to be integers.
//     // We cannot allow arbitrary intervals since we want the returned points
//     // to be uniformly sized.
//     if (fCount != 2 ||
//         !SkScalarNearlyEqual(fIntervals[0], fIntervals[1]) ||
//         !SkScalarIsInt(fIntervals[0]) ||
//         !SkScalarIsInt(fIntervals[1])) {
//         return false;
//     }
//
//     SkPoint pts[2];
//
//     if (!src.isLine(pts)) {
//         return false;
//     }
//
//     // TODO: this test could be eased up to allow circles
//     if (SkPaint::kButt_Cap != rec.getCap()) {
//         return false;
//     }
//
//     // TODO: this test could be eased up for circles. Rotations could be allowed.
//     if (!matrix.rectStaysRect()) {
//         return false;
//     }
//
//     // See if the line can be limited to something plausible.
//     if (!cull_line(pts, rec, matrix, cullRect, fIntervalLength)) {
//         return false;
//     }
//
//     SkScalar length = SkPoint::Distance(pts[1], pts[0]);
//
//     SkVector tangent = pts[1] - pts[0];
//     if (tangent.isZero()) {
//         return false;
//     }
//
//     tangent.scale(SkScalarInvert(length));
//
//     // TODO: make this test for horizontal & vertical lines more robust
//     bool isXAxis = true;
//     if (SkScalarNearlyEqual(SK_Scalar1, tangent.fX) ||
//         SkScalarNearlyEqual(-SK_Scalar1, tangent.fX)) {
//         results->fSize.set(SkScalarHalf(fIntervals[0]), SkScalarHalf(rec.getWidth()));
//     } else if (SkScalarNearlyEqual(SK_Scalar1, tangent.fY) ||
//                SkScalarNearlyEqual(-SK_Scalar1, tangent.fY)) {
//         results->fSize.set(SkScalarHalf(rec.getWidth()), SkScalarHalf(fIntervals[0]));
//         isXAxis = false;
//     } else if (SkPaint::kRound_Cap != rec.getCap()) {
//         // Angled lines don't have axis-aligned boxes.
//         return false;
//     }
//
//     if (results) {
//         results->fFlags = 0;
//         SkScalar clampedInitialDashLength = std::min(length, fInitialDashLength);
//
//         if (SkPaint::kRound_Cap == rec.getCap()) {
//             results->fFlags |= PointData::kCircles_PointFlag;
//         }
//
//         results->fNumPoints = 0;
//         SkScalar len2 = length;
//         if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) {
//             SkASSERT(len2 >= clampedInitialDashLength);
//             if (0 == fInitialDashIndex) {
//                 if (clampedInitialDashLength > 0) {
//                     if (clampedInitialDashLength >= fIntervals[0]) {
//                         ++results->fNumPoints;  // partial first dash
//                     }
//                     len2 -= clampedInitialDashLength;
//                 }
//                 len2 -= fIntervals[1];  // also skip first space
//                 if (len2 < 0) {
//                     len2 = 0;
//                 }
//             } else {
//                 len2 -= clampedInitialDashLength; // skip initial partial empty
//             }
//         }
//         // Too many midpoints can cause results->fNumPoints to overflow or
//         // otherwise cause the results->fPoints allocation below to OOM.
//         // Cap it to a sane value.
//         SkScalar numIntervals = len2 / fIntervalLength;
//         if (!SkIsFinite(numIntervals) || numIntervals > SkDashPath::kMaxDashCount) {
//             return false;
//         }
//         int numMidPoints = SkScalarFloorToInt(numIntervals);
//         results->fNumPoints += numMidPoints;
//         len2 -= numMidPoints * fIntervalLength;
//         bool partialLast = false;
//         if (len2 > 0) {
//             if (len2 < fIntervals[0]) {
//                 partialLast = true;
//             } else {
//                 ++numMidPoints;
//                 ++results->fNumPoints;
//             }
//         }
//
//         results->fPoints = new SkPoint[results->fNumPoints];
//
//         SkScalar    distance = 0;
//         int         curPt = 0;
//
//         if (clampedInitialDashLength > 0 || 0 == fInitialDashIndex) {
//             SkASSERT(clampedInitialDashLength <= length);
//
//             if (0 == fInitialDashIndex) {
//                 if (clampedInitialDashLength > 0) {
//                     // partial first block
//                     SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles
//                     SkScalar x = pts[0].fX + tangent.fX * SkScalarHalf(clampedInitialDashLength);
//                     SkScalar y = pts[0].fY + tangent.fY * SkScalarHalf(clampedInitialDashLength);
//                     SkScalar halfWidth, halfHeight;
//                     if (isXAxis) {
//                         halfWidth = SkScalarHalf(clampedInitialDashLength);
//                         halfHeight = SkScalarHalf(rec.getWidth());
//                     } else {
//                         halfWidth = SkScalarHalf(rec.getWidth());
//                         halfHeight = SkScalarHalf(clampedInitialDashLength);
//                     }
//                     if (clampedInitialDashLength < fIntervals[0]) {
//                         // This one will not be like the others
//                         results->fFirst.addRect(x - halfWidth, y - halfHeight,
//                                                 x + halfWidth, y + halfHeight);
//                     } else {
//                         SkASSERT(curPt < results->fNumPoints);
//                         results->fPoints[curPt].set(x, y);
//                         ++curPt;
//                     }
//
//                     distance += clampedInitialDashLength;
//                 }
//
//                 distance += fIntervals[1];  // skip over the next blank block too
//             } else {
//                 distance += clampedInitialDashLength;
//             }
//         }
//
//         if (0 != numMidPoints) {
//             distance += SkScalarHalf(fIntervals[0]);
//
//             for (int i = 0; i < numMidPoints; ++i) {
//                 SkScalar x = pts[0].fX + tangent.fX * distance;
//                 SkScalar y = pts[0].fY + tangent.fY * distance;
//
//                 SkASSERT(curPt < results->fNumPoints);
//                 results->fPoints[curPt].set(x, y);
//                 ++curPt;
//
//                 distance += fIntervalLength;
//             }
//
//             distance -= SkScalarHalf(fIntervals[0]);
//         }
//
//         if (partialLast) {
//             // partial final block
//             SkASSERT(SkPaint::kRound_Cap != rec.getCap()); // can't handle partial circles
//             SkScalar temp = length - distance;
//             SkASSERT(temp < fIntervals[0]);
//             SkScalar x = pts[0].fX + tangent.fX * (distance + SkScalarHalf(temp));
//             SkScalar y = pts[0].fY + tangent.fY * (distance + SkScalarHalf(temp));
//             SkScalar halfWidth, halfHeight;
//             if (isXAxis) {
//                 halfWidth = SkScalarHalf(temp);
//                 halfHeight = SkScalarHalf(rec.getWidth());
//             } else {
//                 halfWidth = SkScalarHalf(rec.getWidth());
//                 halfHeight = SkScalarHalf(temp);
//             }
//             results->fLast.addRect(x - halfWidth, y - halfHeight,
//                                    x + halfWidth, y + halfHeight);
//         }
//
//         SkASSERT(curPt == results->fNumPoints);
//     }
//
//     return true;
}

SkPathEffect::DashType SkDashImpl::onAsADash(DashInfo *info) const {
    if (info) {
        if (info->fCount >= fCount && info->fIntervals) {
            memcpy(info->fIntervals, fIntervals, fCount * sizeof(SkScalar));
        }
        info->fCount = fCount;
        info->fPhase = fPhase;
    }
    return kDash_DashType;
}

void SkDashImpl::flatten(SkWriteBuffer &buffer) const {
    buffer.writeScalar(fPhase);
    buffer.writeScalarArray(fIntervals, fCount);
}

sk_sp<SkFlattenable> SkDashImpl::CreateProc(SkReadBuffer& buffer) {
    const SkScalar phase = buffer.readScalar();
    uint32_t count = buffer.getArrayCount();

    // Don't allocate gigantic buffers if there's not data for them.
    if (!buffer.validateCanReadN<SkScalar>(count)) {
        return nullptr;
    }

    AutoSTArray<32, SkScalar> intervals(count);
    if (buffer.readScalarArray(intervals.get(), count)) {
        return SkDashPathEffect::Make(intervals.get(), SkToInt(count), phase);
    }
    return nullptr;
}

//////////////////////////////////////////////////////////////////////////////////////////////////

sk_sp<SkPathEffect> SkDashPathEffect::Make(const SkScalar intervals[], int count, SkScalar phase) {
//     if (!SkDashPath::ValidDashPath(phase, intervals, count)) {
//         return nullptr;
//     }
    return sk_sp<SkPathEffect>(new SkDashImpl(intervals, count, phase));
}
